/**
 * @file validation_utils.c
 * @brief 验证工具函数实现
 * @details 本文件实现了104协议中各种验证功能，
 *          包括超时参数验证、地址范围验证、QOI验证等。
 * 
 * @author zyb
 * @date 2025-10-03
 * @version 1.0
 * 
 * @note 验证函数严格按照IEC 60870-5-104协议规范
 * @warning 所有验证函数都会进行严格的参数检查
 * 
 * @see protocol_types.h
 * @see constants.h
 * @see error_codes.h
 */

#include "validation_utils.h"
#include "../../types/include/protocol_types.h"
#include "../../types/include/constants.h"
#include "../../error/include/error_codes.h"
#include "../../../common/logs/include/logger.h"
#include <string.h>

// 定义模块名称
#define LOG_MODULE_NAME "VALIDATION_UTILS"

/* ==================== 超时参数验证函数实现 ==================== */

/**
 * @brief 验证超时参数
 * @details 验证t0、t1、t2、t3超时参数是否符合协议规范
 * 
 * @param t0 建立连接超时 (1-255秒)
 * @param t1 发送或测试APDU超时 (1-255秒)
 * @param t2 无数据报文时确认超时 (1-255秒)
 * @param t3 长期空闲状态下发送测试帧超时 (1-255秒)
 * @return 协议错误码
 */
protocol_error_t validate_timeout_params(uint8_t t0, uint8_t t1, uint8_t t2, uint8_t t3) {
    // 验证超时参数范围
    if (t0 < TIMEOUT_T0_MIN) {
        LOG_ERROR(LOG_MODULE_NAME, "t0超时参数超出范围: %d (范围: %d-%d)", t0, TIMEOUT_T0_MIN, TIMEOUT_T0_MAX);
        return PROTOCOL_ERROR_INVALID_PARAM;
    }
    
    if (t1 < TIMEOUT_T1_MIN) {
        LOG_ERROR(LOG_MODULE_NAME, "t1超时参数超出范围: %d (范围: %d-%d)", t1, TIMEOUT_T1_MIN, TIMEOUT_T1_MAX);
        return PROTOCOL_ERROR_INVALID_PARAM;
    }
    
    if (t2 < TIMEOUT_T2_MIN) {
        LOG_ERROR(LOG_MODULE_NAME, "t2超时参数超出范围: %d (范围: %d-%d)", t2, TIMEOUT_T2_MIN, TIMEOUT_T2_MAX);
        return PROTOCOL_ERROR_INVALID_PARAM;
    }
    
    if (t3 < TIMEOUT_T3_MIN) {
        LOG_ERROR(LOG_MODULE_NAME, "t3超时参数超出范围: %d (范围: %d-%d)", t3, TIMEOUT_T3_MIN, TIMEOUT_T3_MAX);
        return PROTOCOL_ERROR_INVALID_PARAM;
    }
    
    // 验证t2 < t1
    if (t2 >= t1) {
        LOG_ERROR(LOG_MODULE_NAME, "t2必须小于t1: t2=%d, t1=%d", t2, t1);
        return PROTOCOL_ERROR_INVALID_PARAM;
    }
    
    LOG_DEBUG(LOG_MODULE_NAME, "超时参数验证成功: t0=%d, t1=%d, t2=%d, t3=%d", t0, t1, t2, t3);
    return PROTOCOL_SUCCESS;
}

/* ==================== 地址范围验证函数实现 ==================== */

/**
 * @brief 验证地址范围
 * @details 验证信息对象地址是否在指定版本的地址范围内
 * 
 * @param address 信息对象地址
 * @param version 协议版本 (1997或2002)
 * @return 协议错误码
 */
protocol_error_t validate_address_range(uint32_t address, uint16_t version) {
    if (version == 1997) {
        if ((address >= ADDR_TELEMETRY_START_1997 && address <= ADDR_TELEMETRY_END_1997) ||
            (address >= ADDR_ANALOG_START_1997 && address <= ADDR_ANALOG_END_1997) ||
            (address >= ADDR_CONTROL_START_1997 && address <= ADDR_CONTROL_END_1997)) {
            LOG_DEBUG(LOG_MODULE_NAME, "1997版地址验证成功: 0x%08X", address);
            return PROTOCOL_SUCCESS;
        }
    } else if (version == 2002) {
        if ((address >= ADDR_TELEMETRY_START_2002 && address <= ADDR_TELEMETRY_END_2002) ||
            (address >= ADDR_ANALOG_START_2002 && address <= ADDR_ANALOG_END_2002) ||
            (address >= ADDR_CONTROL_START_2002 && address <= ADDR_CONTROL_END_2002) ||
            (address >= ADDR_ENERGY_START_2002 && address <= ADDR_ENERGY_END_2002) ||
            (address >= ADDR_PARAMETER_START_2002 && address <= ADDR_PARAMETER_END_2002)) {
            LOG_DEBUG(LOG_MODULE_NAME, "2002版地址验证成功: 0x%08X", address);
            return PROTOCOL_SUCCESS;
        }
    } else {
        LOG_ERROR(LOG_MODULE_NAME, "不支持的协议版本: %d", version);
        return PROTOCOL_ERROR_INVALID_PARAM;
    }
    
    LOG_ERROR(LOG_MODULE_NAME, "地址超出范围: 0x%08X (版本: %d)", address, version);
    return PROTOCOL_ERROR_ASDU_INVALID_ADDRESS;
}

/**
 * @brief 验证公共地址
 * @details 验证公共地址是否在有效范围内
 * 
 * @param common_addr 公共地址
 * @return 协议错误码
 */
protocol_error_t validate_common_address(uint16_t common_addr) {
    if (common_addr < COMMON_ADDR_MIN) {
        LOG_ERROR(LOG_MODULE_NAME, "公共地址超出范围: %d (范围: %d-%d)", 
                  common_addr, COMMON_ADDR_MIN, COMMON_ADDR_MAX);
        return PROTOCOL_ERROR_ASDU_INVALID_ADDRESS;
    }
    
    LOG_DEBUG(LOG_MODULE_NAME, "公共地址验证成功: %d", common_addr);
    return PROTOCOL_SUCCESS;
}

/* ==================== QOI验证函数实现 ==================== */

/**
 * @brief 验证QOI限定词
 * @details 验证QOI限定词是否符合协议规范
 * 
 * @param qoi QOI限定词值
 * @return 协议错误码
 */
protocol_error_t validate_qoi(uint8_t qoi) {
    if (qoi == QOI_UNUSED) {
        LOG_ERROR(LOG_MODULE_NAME, "QOI限定词不能为未用值: %d", qoi);
        return PROTOCOL_ERROR_INVALID_PARAM;
    }
    
    if (qoi >= QOI_COMPANION_STANDARD_MIN && qoi <= QOI_COMPANION_STANDARD_MAX) {
        LOG_DEBUG(LOG_MODULE_NAME, "QOI限定词验证成功 (配套标准保留): %d", qoi);
        return PROTOCOL_SUCCESS;
    }
    
    if (qoi == QOI_ENTIRE_STATION) {
        LOG_DEBUG(LOG_MODULE_NAME, "QOI限定词验证成功 (整个站的总召唤): %d", qoi);
        return PROTOCOL_SUCCESS;
    }
    
    if (qoi >= QOI_SPECIAL_PURPOSE_MIN) {
        LOG_DEBUG(LOG_MODULE_NAME, "QOI限定词验证成功 (特殊用途保留): %d", qoi);
        return PROTOCOL_SUCCESS;
    }
    
    LOG_ERROR(LOG_MODULE_NAME, "QOI限定词超出有效范围: %d", qoi);
    return PROTOCOL_ERROR_INVALID_PARAM;
}

/* ==================== 序列号验证函数实现 ==================== */

/**
 * @brief 验证序列号
 * @details 验证发送和接收序列号是否在有效范围内
 * 
 * @param send_seq 发送序列号
 * @param receive_seq 接收序列号
 * @return 协议错误码
 */
protocol_error_t validate_sequence_numbers(uint16_t send_seq, uint16_t receive_seq) {
    if (send_seq > MAX_SEND_SEQUENCE_NUMBER) {
        LOG_ERROR(LOG_MODULE_NAME, "发送序列号超出范围: %d (最大值: %d)", send_seq, MAX_SEND_SEQUENCE_NUMBER);
        return PROTOCOL_ERROR_INVALID_PARAM;
    }
    
    if (receive_seq > MAX_RECEIVE_SEQUENCE_NUMBER) {
        LOG_ERROR(LOG_MODULE_NAME, "接收序列号超出范围: %d (最大值: %d)", receive_seq, MAX_RECEIVE_SEQUENCE_NUMBER);
        return PROTOCOL_ERROR_INVALID_PARAM;
    }
    
    LOG_DEBUG(LOG_MODULE_NAME, "序列号验证成功: 发送=%d, 接收=%d", send_seq, receive_seq);
    return PROTOCOL_SUCCESS;
}

/* ==================== 类型标识验证函数实现 ==================== */

/**
 * @brief 验证类型标识
 * @details 验证类型标识是否在有效范围内
 * 
 * @param type_id 类型标识
 * @return 协议错误码
 */
protocol_error_t validate_type_id(uint8_t type_id) {
    // 根据协议规范，类型标识的有效范围
    if (type_id == 0) {
        LOG_ERROR(LOG_MODULE_NAME, "类型标识不能为0");
        return PROTOCOL_ERROR_INVALID_PARAM;
    }
    
    // 检查常见的有效类型标识
    switch (type_id) {
        case TYPE_ID_SINGLE_POINT:
        case TYPE_ID_DOUBLE_POINT:
        case TYPE_ID_MEASUREMENT_NORMALIZED:
        case TYPE_ID_MEASUREMENT_SCALED:
        case TYPE_ID_MEASUREMENT_SHORT_FLOAT:
        case TYPE_ID_SINGLE_POINT_SOE:
        case TYPE_ID_DOUBLE_POINT_SOE:
        case TYPE_ID_FAULT_EVENT:
        case TYPE_ID_SINGLE_COMMAND:
        case TYPE_ID_DOUBLE_COMMAND:
        case TYPE_ID_CLOCK_SYNC:
        case TYPE_ID_TOTAL_INTERROGATION:
        case TYPE_ID_ENERGY_INTERROGATION:
        case TYPE_ID_TEST_COMMAND:
        case TYPE_ID_RESET_PROCESS:
            LOG_DEBUG(LOG_MODULE_NAME, "类型标识验证成功: %d", type_id);
            return PROTOCOL_SUCCESS;
        default:
            // 对于其他类型标识，检查是否在合理范围内
            if (type_id >= 1) {
                LOG_DEBUG(LOG_MODULE_NAME, "类型标识验证成功 (未知类型): %d", type_id);
                return PROTOCOL_SUCCESS;
            } else {
                LOG_ERROR(LOG_MODULE_NAME, "类型标识超出范围: %d", type_id);
                return PROTOCOL_ERROR_INVALID_PARAM;
            }
    }
}

/* ==================== 传送原因验证函数实现 ==================== */

/**
 * @brief 验证传送原因
 * @details 验证传送原因是否在有效范围内
 * 
 * @param cot 传送原因
 * @return 协议错误码
 */
protocol_error_t validate_cause_of_transmission(uint16_t cot) {
    // 根据协议规范，传送原因的有效范围
    if (cot == 0) {
        LOG_ERROR(LOG_MODULE_NAME, "传送原因不能为0");
        return PROTOCOL_ERROR_INVALID_PARAM;
    }
    
    // 检查常见的有效传送原因
    switch (cot) {
        case COT_PERIODIC:
        case COT_BACKGROUND_SCAN:
        case COT_SPONTANEOUS:
        case COT_INITIALIZATION:
        case COT_REQUEST:
        case COT_ACTIVATION:
        case COT_ACTIVATION_CONFIRM:
        case COT_DEACTIVATION:
        case COT_DEACTIVATION_CONFIRM:
        case COT_ACTIVATION_TERMINATION:
        case COT_REMOTE_COMMAND:
        case COT_LOCAL_COMMAND:
        case COT_FILE_TRANSFER:
        case COT_RESPONSE_STATION_INTERROGATION:
        case COT_RESPONSE_GROUP1:
        case COT_RESPONSE_GROUP2:
        case COT_RESPONSE_GROUP3:
        case COT_RESPONSE_GROUP4:
        case COT_RESPONSE_GROUP5:
        case COT_RESPONSE_GROUP6:
        case COT_RESPONSE_GROUP7:
        case COT_RESPONSE_GROUP8:
        case COT_RESPONSE_GROUP9:
        case COT_RESPONSE_GROUP10:
        case COT_RESPONSE_GROUP11:
        case COT_RESPONSE_GROUP12:
        case COT_RESPONSE_GROUP13:
        case COT_RESPONSE_GROUP14:
        case COT_RESPONSE_GROUP15:
        case COT_RESPONSE_GROUP16:
            LOG_DEBUG(LOG_MODULE_NAME, "传送原因验证成功: %d", cot);
            return PROTOCOL_SUCCESS;
        default:
            // 对于其他传送原因，检查是否在合理范围内
            if (cot >= 1) {
                LOG_DEBUG(LOG_MODULE_NAME, "传送原因验证成功 (未知原因): %d", cot);
                return PROTOCOL_SUCCESS;
            } else {
                LOG_ERROR(LOG_MODULE_NAME, "传送原因超出范围: %d", cot);
                return PROTOCOL_ERROR_INVALID_PARAM;
            }
    }
}

/* ==================== 综合验证函数实现 ==================== */

/**
 * @brief 验证APDU基本参数
 * @details 验证APDU的基本参数是否有效
 * 
 * @param length APDU长度
 * @param send_seq 发送序列号
 * @param receive_seq 接收序列号
 * @return 协议错误码
 */
protocol_error_t validate_apdu_basic_params(uint8_t length, uint16_t send_seq, uint16_t receive_seq) {
    // 验证APDU长度
    if (length < APDU_MIN_LENGTH || length > APDU_MAX_LENGTH) {
        LOG_ERROR(LOG_MODULE_NAME, "APDU长度超出范围: %d (范围: %d-%d)", 
                  length, APDU_MIN_LENGTH, APDU_MAX_LENGTH);
        return PROTOCOL_ERROR_INVALID_PARAM;
    }
    
    // 验证序列号
    protocol_error_t result = validate_sequence_numbers(send_seq, receive_seq);
    if (result != PROTOCOL_SUCCESS) {
        return result;
    }
    
    LOG_DEBUG(LOG_MODULE_NAME, "APDU基本参数验证成功: 长度=%d, 发送=%d, 接收=%d", 
              length, send_seq, receive_seq);
    return PROTOCOL_SUCCESS;
}

/**
 * @brief 验证ASDU基本参数
 * @details 验证ASDU的基本参数是否有效
 * 
 * @param type_id 类型标识
 * @param cot 传送原因
 * @param common_addr 公共地址
 * @return 协议错误码
 */
protocol_error_t validate_asdu_basic_params(uint8_t type_id, uint16_t cot, uint16_t common_addr) {
    // 验证类型标识
    protocol_error_t result = validate_type_id(type_id);
    if (result != PROTOCOL_SUCCESS) {
        return result;
    }
    
    // 验证传送原因
    result = validate_cause_of_transmission(cot);
    if (result != PROTOCOL_SUCCESS) {
        return result;
    }
    
    // 验证公共地址
    result = validate_common_address(common_addr);
    if (result != PROTOCOL_SUCCESS) {
        return result;
    }
    
    LOG_DEBUG(LOG_MODULE_NAME, "ASDU基本参数验证成功: 类型=%d, 原因=%d, 地址=%d", 
              type_id, cot, common_addr);
    return PROTOCOL_SUCCESS;
}

/* ==================== 具体验证函数实现 ==================== */

/**
 * @brief 验证信息对象地址
 * @details 验证信息对象地址是否在有效范围内
 * 
 * @param address 信息对象地址
 * @return 验证结果
 *         - 1: 地址有效
 *         - 0: 地址无效
 */
int is_info_address_valid(uint32_t address) {
    // 地址范围：1-16777215 (0xFFFFFF)
    return (address >= 1 && address <= 0xFFFFFF);
}

/**
 * @brief 验证类型标识
 * @details 验证类型标识是否在有效范围内
 * 
 * @param type_id 类型标识
 * @return 验证结果
 *         - 1: 类型标识有效
 *         - 0: 类型标识无效
 */
int is_type_id_valid(uint8_t type_id) {
    return (type_id >= 1);
}

/**
 * @brief 验证传送原因
 * @details 验证传送原因是否在有效范围内
 * 
 * @param cot 传送原因
 * @return 验证结果
 *         - 1: 传送原因有效
 *         - 0: 传送原因无效
 */
int is_cause_of_transmission_valid(uint16_t cot) {
    return (cot >= 1);
}

/**
 * @brief 验证公共地址
 * @details 验证公共地址是否在有效范围内
 * 
 * @param common_addr 公共地址
 * @return 验证结果
 *         - 1: 公共地址有效
 *         - 0: 公共地址无效
 */
int is_common_address_valid(uint16_t common_addr) {
    return (common_addr >= 1);
}

/**
 * @brief 验证VSQ
 * @details 验证VSQ是否在有效范围内
 * 
 * @param vsq VSQ值
 * @return 验证结果
 *         - 1: VSQ有效
 *         - 0: VSQ无效
 */
int is_vsq_valid(uint8_t vsq) {
    return (vsq <= 127); // VSQ最高位为0，范围0-127
}

/**
 * @brief 计算ASDU信息对象大小
 * @details 根据类型标识计算信息对象大小
 * 
 * @param type_id 类型标识
 * @return 信息对象大小（字节）
 */
uint32_t calculate_asdu_info_object_size(uint8_t type_id) {
    switch (type_id) {
        case 1:  // 单点信息
        case 2:  // 双点信息
        case 3:  // 测量值，归一化值
        case 4:  // 测量值，标度化值
        case 5:  // 测量值，短浮点数
        case 6:  // 测量值，短浮点数
        case 7:  // 测量值，短浮点数
        case 8:  // 测量值，短浮点数
        case 9:  // 测量值，短浮点数
        case 10: // 测量值，短浮点数
        case 11: // 测量值，短浮点数
        case 12: // 测量值，短浮点数
        case 13: // 测量值，短浮点数
        case 14: // 测量值，短浮点数
        case 15: // 测量值，短浮点数
        case 16: // 测量值，短浮点数
        case 17: // 测量值，短浮点数
        case 18: // 测量值，短浮点数
        case 19: // 测量值，短浮点数
        case 20: // 测量值，短浮点数
        case 21: // 测量值，短浮点数
        case 22: // 测量值，短浮点数
        case 23: // 测量值，短浮点数
        case 24: // 测量值，短浮点数
        case 25: // 测量值，短浮点数
        case 26: // 测量值，短浮点数
        case 27: // 测量值，短浮点数
        case 28: // 测量值，短浮点数
        case 29: // 测量值，短浮点数
        case 30: // 测量值，短浮点数
        case 31: // 测量值，短浮点数
        case 32: // 测量值，短浮点数
        case 33: // 测量值，短浮点数
        case 34: // 测量值，短浮点数
        case 35: // 测量值，短浮点数
        case 36: // 测量值，短浮点数
        case 37: // 测量值，短浮点数
        case 38: // 测量值，短浮点数
        case 39: // 测量值，短浮点数
        case 40: // 测量值，短浮点数
        case 41: // 测量值，短浮点数
        case 42: // 测量值，短浮点数
        case 43: // 测量值，短浮点数
        case 44: // 测量值，短浮点数
        case 45: // 测量值，短浮点数
        case 46: // 测量值，短浮点数
        case 47: // 测量值，短浮点数
        case 48: // 测量值，短浮点数
        case 49: // 测量值，短浮点数
        case 50: // 测量值，短浮点数
        case 51: // 测量值，短浮点数
        case 52: // 测量值，短浮点数
        case 53: // 测量值，短浮点数
        case 54: // 测量值，短浮点数
        case 55: // 测量值，短浮点数
        case 56: // 测量值，短浮点数
        case 57: // 测量值，短浮点数
        case 58: // 测量值，短浮点数
        case 59: // 测量值，短浮点数
        case 60: // 测量值，短浮点数
        case 61: // 测量值，短浮点数
        case 62: // 测量值，短浮点数
        case 63: // 测量值，短浮点数
        case 64: // 测量值，短浮点数
        case 65: // 测量值，短浮点数
        case 66: // 测量值，短浮点数
        case 67: // 测量值，短浮点数
        case 68: // 测量值，短浮点数
        case 69: // 测量值，短浮点数
        case 70: // 测量值，短浮点数
        case 71: // 测量值，短浮点数
        case 72: // 测量值，短浮点数
        case 73: // 测量值，短浮点数
        case 74: // 测量值，短浮点数
        case 75: // 测量值，短浮点数
        case 76: // 测量值，短浮点数
        case 77: // 测量值，短浮点数
        case 78: // 测量值，短浮点数
        case 79: // 测量值，短浮点数
        case 80: // 测量值，短浮点数
        case 81: // 测量值，短浮点数
        case 82: // 测量值，短浮点数
        case 83: // 测量值，短浮点数
        case 84: // 测量值，短浮点数
        case 85: // 测量值，短浮点数
        case 86: // 测量值，短浮点数
        case 87: // 测量值，短浮点数
        case 88: // 测量值，短浮点数
        case 89: // 测量值，短浮点数
        case 90: // 测量值，短浮点数
        case 91: // 测量值，短浮点数
        case 92: // 测量值，短浮点数
        case 93: // 测量值，短浮点数
        case 94: // 测量值，短浮点数
        case 95: // 测量值，短浮点数
        case 96: // 测量值，短浮点数
        case 97: // 测量值，短浮点数
        case 98: // 测量值，短浮点数
        case 99: // 测量值，短浮点数
        case 100: // 测量值，短浮点数
        case 101: // 测量值，短浮点数
        case 102: // 测量值，短浮点数
        case 103: // 测量值，短浮点数
        case 104: // 测量值，短浮点数
        case 105: // 测量值，短浮点数
        case 106: // 测量值，短浮点数
        case 107: // 测量值，短浮点数
        case 108: // 测量值，短浮点数
        case 109: // 测量值，短浮点数
        case 110: // 测量值，短浮点数
        case 111: // 测量值，短浮点数
        case 112: // 测量值，短浮点数
        case 113: // 测量值，短浮点数
        case 114: // 测量值，短浮点数
        case 115: // 测量值，短浮点数
        case 116: // 测量值，短浮点数
        case 117: // 测量值，短浮点数
        case 118: // 测量值，短浮点数
        case 119: // 测量值，短浮点数
        case 120: // 测量值，短浮点数
        case 121: // 测量值，短浮点数
        case 122: // 测量值，短浮点数
        case 123: // 测量值，短浮点数
        case 124: // 测量值，短浮点数
        case 125: // 测量值，短浮点数
        case 126: // 测量值，短浮点数
        case 127: // 测量值，短浮点数
        case 128: // 测量值，短浮点数
        case 129: // 测量值，短浮点数
        case 130: // 测量值，短浮点数
        case 131: // 测量值，短浮点数
        case 132: // 测量值，短浮点数
        case 133: // 测量值，短浮点数
        case 134: // 测量值，短浮点数
        case 135: // 测量值，短浮点数
        case 136: // 测量值，短浮点数
        case 137: // 测量值，短浮点数
        case 138: // 测量值，短浮点数
        case 139: // 测量值，短浮点数
        case 140: // 测量值，短浮点数
        case 141: // 测量值，短浮点数
        case 142: // 测量值，短浮点数
        case 143: // 测量值，短浮点数
        case 144: // 测量值，短浮点数
        case 145: // 测量值，短浮点数
        case 146: // 测量值，短浮点数
        case 147: // 测量值，短浮点数
        case 148: // 测量值，短浮点数
        case 149: // 测量值，短浮点数
        case 150: // 测量值，短浮点数
        case 151: // 测量值，短浮点数
        case 152: // 测量值，短浮点数
        case 153: // 测量值，短浮点数
        case 154: // 测量值，短浮点数
        case 155: // 测量值，短浮点数
        case 156: // 测量值，短浮点数
        case 157: // 测量值，短浮点数
        case 158: // 测量值，短浮点数
        case 159: // 测量值，短浮点数
        case 160: // 测量值，短浮点数
        case 161: // 测量值，短浮点数
        case 162: // 测量值，短浮点数
        case 163: // 测量值，短浮点数
        case 164: // 测量值，短浮点数
        case 165: // 测量值，短浮点数
        case 166: // 测量值，短浮点数
        case 167: // 测量值，短浮点数
        case 168: // 测量值，短浮点数
        case 169: // 测量值，短浮点数
        case 170: // 测量值，短浮点数
        case 171: // 测量值，短浮点数
        case 172: // 测量值，短浮点数
        case 173: // 测量值，短浮点数
        case 174: // 测量值，短浮点数
        case 175: // 测量值，短浮点数
        case 176: // 测量值，短浮点数
        case 177: // 测量值，短浮点数
        case 178: // 测量值，短浮点数
        case 179: // 测量值，短浮点数
        case 180: // 测量值，短浮点数
        case 181: // 测量值，短浮点数
        case 182: // 测量值，短浮点数
        case 183: // 测量值，短浮点数
        case 184: // 测量值，短浮点数
        case 185: // 测量值，短浮点数
        case 186: // 测量值，短浮点数
        case 187: // 测量值，短浮点数
        case 188: // 测量值，短浮点数
        case 189: // 测量值，短浮点数
        case 190: // 测量值，短浮点数
        case 191: // 测量值，短浮点数
        case 192: // 测量值，短浮点数
        case 193: // 测量值，短浮点数
        case 194: // 测量值，短浮点数
        case 195: // 测量值，短浮点数
        case 196: // 测量值，短浮点数
        case 197: // 测量值，短浮点数
        case 198: // 测量值，短浮点数
        case 199: // 测量值，短浮点数
        case 200: // 测量值，短浮点数
        case 201: // 测量值，短浮点数
        case 202: // 测量值，短浮点数
        case 203: // 测量值，短浮点数
        case 204: // 测量值，短浮点数
        case 205: // 测量值，短浮点数
        case 206: // 测量值，短浮点数
        case 207: // 测量值，短浮点数
        case 208: // 测量值，短浮点数
        case 209: // 测量值，短浮点数
        case 210: // 测量值，短浮点数
        case 211: // 测量值，短浮点数
        case 212: // 测量值，短浮点数
        case 213: // 测量值，短浮点数
        case 214: // 测量值，短浮点数
        case 215: // 测量值，短浮点数
        case 216: // 测量值，短浮点数
        case 217: // 测量值，短浮点数
        case 218: // 测量值，短浮点数
        case 219: // 测量值，短浮点数
        case 220: // 测量值，短浮点数
        case 221: // 测量值，短浮点数
        case 222: // 测量值，短浮点数
        case 223: // 测量值，短浮点数
        case 224: // 测量值，短浮点数
        case 225: // 测量值，短浮点数
        case 226: // 测量值，短浮点数
        case 227: // 测量值，短浮点数
        case 228: // 测量值，短浮点数
        case 229: // 测量值，短浮点数
        case 230: // 测量值，短浮点数
        case 231: // 测量值，短浮点数
        case 232: // 测量值，短浮点数
        case 233: // 测量值，短浮点数
        case 234: // 测量值，短浮点数
        case 235: // 测量值，短浮点数
        case 236: // 测量值，短浮点数
        case 237: // 测量值，短浮点数
        case 238: // 测量值，短浮点数
        case 239: // 测量值，短浮点数
        case 240: // 测量值，短浮点数
        case 241: // 测量值，短浮点数
        case 242: // 测量值，短浮点数
        case 243: // 测量值，短浮点数
        case 244: // 测量值，短浮点数
        case 245: // 测量值，短浮点数
        case 246: // 测量值，短浮点数
        case 247: // 测量值，短浮点数
        case 248: // 测量值，短浮点数
        case 249: // 测量值，短浮点数
        case 250: // 测量值，短浮点数
        case 251: // 测量值，短浮点数
        case 252: // 测量值，短浮点数
        case 253: // 测量值，短浮点数
        case 254: // 测量值，短浮点数
        case 255: // 测量值，短浮点数
            return 4; // 地址(3字节) + 品质(1字节)
        default:
            return 0;
    }
}

/**
 * @brief 验证SIQ
 * @details 验证SIQ是否在有效范围内
 * 
 * @param siq SIQ值
 * @return 验证结果
 *         - 1: SIQ有效
 *         - 0: SIQ无效
 */
int is_siq_valid(uint8_t siq) {
    // SIQ的7位保留位必须为0
    return (siq & 0xFE) == 0;
}

/**
 * @brief 验证DIQ
 * @details 验证DIQ是否在有效范围内
 * 
 * @param diq DIQ值
 * @return 验证结果
 *         - 1: DIQ有效
 *         - 0: DIQ无效
 */
int is_diq_valid(uint8_t diq) {
    // DIQ的5位保留位必须为0
    return (diq & 0xE0) == 0;
}

/**
 * @brief 验证QDS
 * @details 验证QDS是否在有效范围内
 * 
 * @param qds QDS值
 * @return 验证结果
 *         - 1: QDS有效
 *         - 0: QDS无效
 */
int is_qds_valid(uint8_t qds) {
    // QDS的5位保留位必须为0
    return (qds & 0xE0) == 0;
}

/**
 * @brief 验证QOS
 * @details 验证QOS是否在有效范围内
 *
 * @param qos QOS值
 * @return 验证结果
 *         - 1: QOS有效
 *         - 0: QOS无效
 */
int is_qos_valid(uint8_t qos) {
    // QOS的2位保留位必须为0
    return (qos & 0xC0) == 0;
}

/**
 * @brief 验证QOI
 * @details 验证QOI是否在有效范围内
 * 
 * @param qoi QOI值
 * @return 验证结果
 *         - 1: QOI有效
 *         - 0: QOI无效
 */
int is_qoi_valid(uint8_t qoi) {
    return (qoi >= 1);
}

/**
 * @brief 验证QOC
 * @details 验证QOC是否在有效范围内
 * 
 * @param qoc QOC值
 * @return 验证结果
 *         - 1: QOC有效
 *         - 0: QOC无效
 */
int is_qoc_valid(uint8_t qoc) {
    // QOC的2位保留位必须为0
    return (qoc & 0xC0) == 0;
}

/**
 * @brief 验证标度化值
 * @details 验证标度化值是否在有效范围内
 * 
 * @param value 标度化值
 * @return 验证结果
 *         - 1: 标度化值有效
 *         - 0: 标度化值无效
 */
int is_scaled_value_valid(int16_t value) {
    // 抑制未使用参数警告
    (void)value;
    return 1; // 标度化值范围：-32768 到 32767
}

/**
 * @brief 验证归一化值
 * @details 验证归一化值是否在有效范围内
 * 
 * @param value 归一化值
 * @return 验证结果
 *         - 1: 归一化值有效
 *         - 0: 归一化值无效
 */
int is_normalized_value_valid(int16_t value) {
    // 抑制未使用参数警告
    (void)value;
    return 1; // 归一化值范围：-32768 到 32767
}

/**
 * @brief 验证短浮点数
 * @details 验证短浮点数是否在有效范围内
 * 
 * @param value 短浮点数
 * @return 验证结果
 *         - 1: 短浮点数有效
 *         - 0: 短浮点数无效
 */
int is_short_float_valid(float value) {
    (void)value; // 抑制未使用参数警告
    return 1; // 短浮点数范围：IEEE 754标准
}